/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
/* vi: set expandtab shiftwidth=4 tabstop=4: */

/**
 * \file
 * <PRE>
 * High performance base64 encoder / decoder
 * Version 1.3 -- 17-Mar-2006
 *
 * Copyright &copy; 2005, 2006, Nick Galbreath -- nickg [at] modp [dot] com
 * All rights reserved.
 *
 * http://modp.com/release/base64
 *
 * Released under bsd license.  See modp_b64.c for details.
 * </pre>
 *
 * The default implementation is the standard b64 encoding with padding.
 * It's easy to change this to use "URL safe" characters and to remove
 * padding.  See the modp_b64.c source code for details.
 *
 */

#ifndef MODP_B64
#define MODP_B64

#ifdef __cplusplus
extern "C" {
#endif

    /**
     * Encode a raw binary string into base 64.
     * src contains the bytes
     * len contains the number of bytes in the src
     * dest should be allocated by the caller to contain
     *   at least modp_b64_encode_len(len) bytes (see below)
     *   This will contain the null-terminated b64 encoded result
     * returns length of the destination string plus the ending null byte
     *    i.e.  the result will be equal to strlen(dest) + 1
     *
     * Example
     *
     * \code
     * char* src = ...;
     * int srclen = ...; //the length of number of bytes in src
     * char* dest = (char*) malloc(modp_b64_encode_len);
     * int len = modp_b64_encode(dest, src, sourcelen);
     * if (len == -1) {
     *   printf("Error\n");
     * } else {
     *   printf("b64 = %s\n", dest);
     * }
     * \endcode
     *
     */
    int modp_b64_encode(char* dest, const char* str, int len);

    /**
     * Decode a base64 encoded string
     *
     * src should contain exactly len bytes of b64 characters.
     *     if src contains -any- non-base characters (such as white
     *     space, -1 is returned.
     *
     * dest should be allocated by the caller to contain at least
     *    len * 3 / 4 bytes.
     *
     * Returns the length (strlen) of the output, or -1 if unable to
     * decode
     *
     * \code
     * char* src = ...;
     * int srclen = ...; // or if you don't know use strlen(src)
     * char* dest = (char*) malloc(modp_b64_decode_len(srclen));
     * int len = modp_b64_decode(dest, src, sourcelen);
     * if (len == -1) { error }
     * \endcode
     */
    int modp_b64_decode(char* dest, const char* src, int len);

    /**
     * Given a source string of length len, this returns the amount of
     * memory the destination string should have.
     *
     * remember, this is integer math
     * 3 bytes turn into 4 chars
     * ceiling[len / 3] * 4 + 1
     *
     * +1 is for any extra null.
     */
#define modp_b64_encode_len(A) ((A+2)/3 * 4 + 1)

     /**
      * Given a base64 string of length len,
      *   this returns the amount of memory required for output string
      *  It maybe be more than the actual number of bytes written.
      * NOTE: remember this is integer math
      * this allocates a bit more memory than traditional versions of b64
      * decode  4 chars turn into 3 bytes
      * floor[len * 3/4] + 2
      */
#define modp_b64_decode_len(A) (A / 4 * 3 + 2)

      /**
       * Will return the strlen of the output from encoding.
       * This may be less than the required number of bytes allocated.
       *
       * This allows you to 'deserialized' a struct
       * \code
       * char* b64encoded = "...";
       * int len = strlen(b64encoded);
       *
       * struct datastuff foo;
       * if (modp_b64_encode_strlen(sizeof(struct datastuff)) != len) {
       *    // wrong size
       *    return false;
       * } else {
       *    // safe to do;
       *    if (modp_b64_decode((char*) &foo, b64encoded, len) == -1) {
       *      // bad characters
       *      return false;
       *    }
       * }
       * // foo is filled out now
       * \endcode
       */
#define modp_b64_encode_strlen(A) ((A + 2)/ 3 * 4)

#ifdef __cplusplus
}

#include <string>

inline std::string& modp_b64_encode(std::string& s)
{
    std::string x(modp_b64_encode_len(s.size()), '\0');
    int d = modp_b64_encode(const_cast<char*>(x.data()), s.data(), s.size());
    x.erase(d, std::string::npos);
    s.swap(x);
    return s;
}

/**
 * base 64 decode a string (self-modifing)
 * On failure, the string is empty.
 *
 * This function is for C++ only (duh)
 *
 * \param[in,out] s the string to be decoded
 * \return a reference to the input string
 */
inline std::string& modp_b64_decode(std::string& s)
{
    std::string x(modp_b64_decode_len(s.size()), '\0');
    int d = modp_b64_decode(const_cast<char*>(x.data()), s.data(), s.size());
    if (d < 0) {
        x.clear();
    }
    else {
        x.erase(d, std::string::npos);
    }
    s.swap(x);
    return s;
}

#endif /* __cplusplus */

#endif /* MODP_B64 */
